home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / video / fly8111-.000 / fly8111- / fly8 / piper.c < prev    next >
C/C++ Source or Header  |  1979-12-31  |  5KB  |  210 lines
  1. /* --------------------------------- piper.c -------------------------------- */
  2.  
  3. /* This is part of the flight simulator 'fly8'.
  4.  * Author: Eyal Lebedinsky (eyal@ise.canberra.edu.au).
  5. */
  6.  
  7. /* Show the piper (aiming reticule) on the Head Up Display.
  8. */
  9.  
  10. #include "plane.h"
  11.  
  12.  
  13. static int    NEAR Csin[] = {8192, 14189}, NEAR Ccos[] = {14189, 8192};
  14.  
  15. extern void FAR
  16. show_piper (HUD *h, OBJECT *obj, OBJECT *target, int x, int y, int dx, int dy,
  17.     int ds, int mode, int off_screen, int dist, int tti, int closure,
  18.     int orgx, int orgy, int clipx, int clipy, int hbottom, int hleft,
  19.     int ss, int shifty)
  20. {
  21.     int    hud1, f15, f16, fa18, ether, knots;
  22.     int    datax, datay, nlines, detail;
  23.     int    t, i, d, dd, ax, ay, bx, by, rx, ry, ratio;
  24.     ANGLE    a;
  25.     long    tc, td;
  26.     char    *name;
  27.     VECT    R;
  28.  
  29.     hud1 = EE(obj)->hud1;
  30.     i = hud1 & HUD_TYPES;
  31.     f16   = i == HUD_F16;
  32.     f15   = i == HUD_F15;
  33.     fa18  = i == HUD_FA18;
  34.     ether = i == HUD_ETHER;
  35.     knots = hud1 & HUD_KNOTS;
  36.  
  37.     if (knots) {
  38.         tc = closure + fmul (closure, 15465);    /* knots */
  39.         td = 3L*dist + fmul (dist, 4601); /* feet */
  40.     } else {
  41.         tc = closure;
  42.         td = dist;
  43.     }
  44.  
  45.     dd = num_size (9L, ss);
  46.  
  47.     if (NEWTGT(obj))
  48.         t = NEWTGT(obj)--&1;
  49.     else
  50.         t = 1;
  51.  
  52.     if (t) {
  53.         ratio = f16 ? F16RAIMC : (f15 ? F15RAIMC : F18RAIMC);
  54.         rx = fmul (dx, ratio);
  55.         ry = fmul (dy, ratio);
  56.         gr_color (ST_HFG);
  57.         gr_ellipse (x, y, rx, ry);
  58.         if (ds > 1) {
  59.             if (hud1 & HUD_THICK)
  60.                 gr_ellipse (x, y, rx+1, ry+1);
  61. /* Target distance
  62. */
  63.             gr_move (x, y-ry);    /* 12 */
  64.             gr_draw (x, y-dy);
  65.             gr_move (x, y+ry);    /* 6 */
  66.             gr_draw (x, y+dy);
  67.             gr_move (x-rx, y);    /* 9 */
  68.             gr_draw (x-dx, y);
  69.             gr_move (x+rx, y);    /* 3 */
  70.             gr_draw (x+dx, y);
  71.             for (i = 0; i < 2; ++i) {    /* ticks */
  72.                 ax = fmul(Csin[i], dx);
  73.                 ay = fmul(Ccos[i], dy);
  74.                 bx = fmul (ax, ratio);
  75.                 by = fmul (ay, ratio);
  76.                 gr_move (x+bx, y+by);
  77.                 gr_draw (x+ax, y+ay);
  78.                 gr_move (x-bx, y+by);
  79.                 gr_draw (x-ax, y+ay);
  80.                 gr_move (x-bx, y-by);
  81.                 gr_draw (x-ax, y-ay);
  82.                 gr_move (x+bx, y-by);
  83.                 gr_draw (x+ax, y-ay);
  84.             }
  85.  
  86.             gr_color (ST_HFGI);
  87.  
  88.             if (td > 11500L)        /* marker */
  89.                 i = 11500;
  90.             else
  91.                 i = (int)td;
  92.             a = muldiv (i, D90, 12000)*4;    /* 360Deg = 12k */
  93.             ax = fmul(SIN (a), rx);
  94.             ay = fmul(COS (a), ry);
  95.             bx = fmul (ax, ratio);        /* use same ratio */
  96.             by = fmul (ay, ratio);
  97.             gr_move (x+ax, y-ay);
  98.             gr_draw (x+bx, y-by);
  99.  
  100. /* Aspect angle(m61) or tti (mk82)
  101. */
  102.             if (WE_MK82 == EE(obj)->weapon) {
  103.                 if (tti > 120)
  104.                     a = 0;
  105.                 else
  106.                     a = muldiv (D90/6, tti, 10)*2;
  107.             } else {
  108.                 VxMmul (R, target->V, obj->T);
  109.                 t = ihypot2d (R[X], R[Z]);
  110.                 a = ATAN (t, -R[Y]);
  111.             }
  112.             ax = fmul (dx, SIN (a));
  113.             ay = fmul (dy, COS (a));
  114.             t = f16 ? F16RASPECT : (FONE-ratio)/2;
  115.             bx = fmul (dx, t);
  116.             by = fmul (dy, t);
  117.             keep_inside (&x, &y, ax-bx, ax+bx, -ay-by, -ay+by,
  118.                 orgx, orgy, clipx, clipy, shifty);
  119.             gr_ellipse (x+ax, y-ay, bx, by);
  120.             if (WE_M61 == EE(obj)->weapon) {
  121. /* Target closure rate
  122. */
  123.                 if (fa18||ether) {
  124.                     if (tc >= 0)    /* show 10s */
  125.                         tc = ((tc+5)/10)*10;
  126.                     else
  127.                         tc = ((tc-5)/10)*10;
  128.                     d = num_size (tc, ss);
  129.                     ax = x+dx;
  130.                     ay = y+dy+ss*5/2;
  131.                     keep_inside (&ax, &ay, -d, 2*dd,
  132.                         -ss-ss/2, 0, orgx, orgy,
  133.                         clipx, clipy, shifty);
  134.                     stroke_num (ax-d, ay-ss/2, tc, ss,
  135.                         ST_HFG);
  136.                     stroke_str (ax,   ay, "Vc", ss, ST_HFG);
  137.                 }
  138. /* Target acceleration vector
  139. */
  140.                 if (hud1 & HUD_ACCVECT) {
  141.                     VxMmul (R, EE(obj)->taccel, obj->T);
  142.                     t = ihypot2d (R[X], R[Z]);
  143.                     if (t < 10*VONE)
  144.                         t = 10*VONE;
  145.                     ax = muldiv (R[X], dx, t);
  146.                     ay = muldiv (R[Z], dy, t);
  147.                     gr_color (ST_HFG);
  148.                     gr_move (x,    y);
  149.                     gr_draw (x+ax, y-ay);
  150.                 }
  151.             }
  152.         }
  153.         gr_color (ST_HFG);
  154.         if (off_screen == 1) {            /* ahead */
  155.             gr_move (x,    y+ry);
  156.             gr_draw (x,    y-ry);
  157.             gr_move (x+rx, y);
  158.             gr_draw (x-rx, y);
  159.         } else if (off_screen == 2){        /* behind */
  160.             d = SIN (D90/2);
  161.             ax = fmul(d, rx);
  162.             ay = fmul(d, ry);
  163.             gr_move (x-ax, y+ay);
  164.             gr_draw (x+ax, y-ay);
  165.             gr_move (x-ax, y-ay);
  166.             gr_draw (x+ax, y+ay);
  167.         } else {
  168.             if (f16) {            /* center circle */
  169.                 rx = fmul (dx, F16RPIP);
  170.                 ry = fmul (dy, F16RPIP);
  171.                 gr_ellipse (x, y, rx, ry);
  172.             }
  173.             gr_color (ST_HFGI);
  174.             gr_move (x, y);            /* center dot */
  175.             gr_draw (x, y);
  176.         }
  177.     }
  178.  
  179.     if (EE(obj)->hud & HUD_DATA) {
  180.         name = get_name (obj, target, mode);
  181.         detail = (1 == ds) || (2&mode);
  182.         nlines = (detail ? 3 : 0) + !!name;
  183.  
  184.         if (2&mode) {
  185.             datax = hleft;
  186.             datay = hbottom+shifty-(nlines-1)*ss;
  187.         } else {
  188.             if (y+dy+nlines*ss >= orgy+clipy+shifty)
  189.                 datay = y-dy-2-(nlines-1)*ss;
  190.             else
  191.                 datay = y+dy+ss;
  192.             datax = 4*dd;
  193.             if (name) {
  194.                 t = stroke_size (name, ss);
  195.                 if (t < datax)
  196.                     t = datax;
  197.             } else
  198.                 t = datax;
  199.  
  200.             t = orgx+clipx-t;
  201.             datax = x-dx;
  202.             if (datax > t)
  203.                 datax = t;
  204.         }
  205.  
  206.         show_data (obj, datax, datay, detail, knots, dist, closure,
  207.             name, tti, mode, ss, ST_HFG);
  208.     }
  209. }
  210.